Panduan Inferensi LLM

LLM Inference API memungkinkan Anda menjalankan model bahasa besar (LLM) sepenuhnya di perangkat, yang dapat Anda gunakan untuk melakukan berbagai tugas, seperti membuat teks, mengambil informasi dalam bentuk bahasa alami, dan merumuskan dokumen. Tugas ini menyediakan dukungan bawaan untuk beberapa model bahasa besar teks ke teks, sehingga Anda dapat menerapkan model AI generatif terbaru di perangkat ke aplikasi dan produk Anda.

Coba sekarang.

Tugas ini memberikan dukungan bawaan untuk berbagai LLM. Model yang dihosting di halaman Komunitas LiteRT tersedia dalam format yang kompatibel dengan MediaPipe dan tidak memerlukan langkah konversi atau kompilasi tambahan.

Anda dapat menggunakan AI Edge Torch untuk mengekspor model PyTorch ke dalam model LiteRT (tflite) multi-tanda tangan, yang dipaketkan dengan parameter tokenizer untuk membuat Task Bundle. Model yang dikonversi dengan AI Edge Torch kompatibel dengan LLM Inference API dan dapat berjalan di backend CPU, sehingga sesuai untuk aplikasi Android dan iOS.

Mulai

Mulai gunakan tugas ini dengan mengikuti salah satu panduan penerapan ini untuk platform target Anda. Panduan khusus platform ini akan memandu Anda dalam penerapan dasar tugas ini, dengan contoh kode yang menggunakan model yang tersedia dan opsi konfigurasi yang direkomendasikan:

Detail tugas

Bagian ini menjelaskan kemampuan, input, output, dan opsi konfigurasi tugas ini.

Fitur

LLM Inference API berisi fitur utama berikut:

  1. Pembuatan teks ke teks - Membuat teks berdasarkan perintah teks input.
  2. Pemilihan LLM - Terapkan beberapa model untuk menyesuaikan aplikasi dengan kasus penggunaan tertentu. Anda juga dapat melatih ulang dan menerapkan bobot yang disesuaikan ke model.
  3. Dukungan LoRA - Memperluas dan menyesuaikan kemampuan LLM dengan model LoRA baik dengan melatih semua set data Anda, atau mengambil model LoRA bawaan yang telah disiapkan dari komunitas open source (tidak kompatibel dengan model yang dikonversi dengan AI Edge Torch Generative API).
Input tugas Output tugas
LLM Inference API menerima input berikut:
  • Perintah teks (misalnya, pertanyaan, subjek email, dokumen yang akan dirangkum)
 LLM Inference API menghasilkan hasil berikut:
  • Teks yang dihasilkan berdasarkan perintah input (misalnya, jawaban atas pertanyaan, draf email, ringkasan dokumen)

Opsi konfigurasi

Tugas ini memiliki opsi konfigurasi berikut:

Nama Opsi Deskripsi Rentang Nilai Nilai Default
modelPath Jalur ke tempat model disimpan dalam direktori project. JALUR T/A
maxTokens Jumlah maksimum token (token input + token output) yang ditangani model. Bilangan Bulat 512
topK Jumlah token yang dipertimbangkan model pada setiap langkah pembuatan. Membatasi prediksi ke token dengan probabilitas tertinggi k. Bilangan Bulat 40
temperature Jumlah keacakan yang diperkenalkan selama pembuatan. Temperatur yang lebih tinggi menghasilkan lebih banyak kreativitas dalam teks yang dihasilkan, sedangkan temperatur yang lebih rendah menghasilkan pembuatan yang lebih dapat diprediksi. Float 0,8
randomSeed Seed acak yang digunakan selama pembuatan teks. Bilangan Bulat 0
loraPath Jalur absolut ke model LoRA secara lokal di perangkat. Catatan: opsi ini hanya kompatibel dengan model GPU. JALUR T/A
resultListener Menetapkan pemroses hasil untuk menerima hasil secara asinkron. Hanya berlaku saat menggunakan metode pembuatan asinkron. T/A T/A
errorListener Menetapkan pemroses error opsional. T/A T/A

Model

LLM Inference API mendukung banyak model bahasa besar teks ke teks, termasuk dukungan bawaan untuk beberapa model yang dioptimalkan untuk berjalan di browser dan perangkat seluler. Model ringan ini dapat digunakan untuk menjalankan inferensi sepenuhnya di perangkat.

Sebelum melakukan inisialisasi LLM Inference API, download model dan simpan file dalam direktori project Anda. Anda dapat menggunakan model yang telah dikonversi sebelumnya dari repositori HuggingFace LiteRT Community, atau mengonversi model ke format yang kompatibel dengan MediaPipe dengan AI Edge Torch Generative Converter.

Jika Anda belum memiliki LLM untuk digunakan dengan LLM Inference API, mulailah dengan salah satu model berikut.

Gemma-3 1B

Gemma-3 1B adalah model terbaru dalam keluarga Gemma yang terdiri dari model open source yang ringan dan canggih, yang dibuat dari riset dan teknologi yang sama dengan yang digunakan untuk membuat model Gemini. Model ini berisi 1 miliar parameter dan bobot terbuka. Varian 1B adalah model paling ringan dalam keluarga Gemma, sehingga ideal untuk banyak kasus penggunaan di perangkat.

Download Gemma-3 1B

Model Gemma-3 1B dari HuggingFace tersedia dalam format .task, dan siap digunakan dengan LLM Inference API untuk aplikasi Android dan Web.

Saat menjalankan Gemma-3 1B dengan LLM Inference API, konfigurasikan opsi berikut dengan benar:

  • preferredBackend: Gunakan opsi ini untuk memilih antara backend CPU atau GPU. Opsi ini hanya tersedia untuk Android.
  • supportedLoraRanks: LLM Inference API tidak dapat dikonfigurasi untuk mendukung Low-Rank Adaptation (LoRA) dengan model Gemma-3 1B. Jangan gunakan opsi supportedLoraRanks atau loraRanks.
  • maxTokens: Nilai untuk maxTokens harus cocok dengan ukuran konteks yang di-build ke dalam model. Hal ini juga dapat disebut sebagai cache Nilai Kunci (KV) atau panjang konteks.
  • numResponses: Harus selalu 1. Opsi ini hanya tersedia untuk Web.

Saat menjalankan Gemma-3 1B di aplikasi web, inisialisasi dapat menyebabkan pemblokiran yang panjang di thread saat ini. Jika memungkinkan, selalu jalankan model dari thread pekerja.

Gemma-2 2B

Gemma-2 2B adalah varian 2B dari Gemma-2, dan berfungsi di semua platform.

Download Gemma-2 2B

Model ini berisi 2B parameter dan bobot terbuka. Gemma-2 2B dikenal dengan keterampilan penalaran canggih untuk model di kelasnya.

Konversi Model PyTorch

Model generatif PyTorch dapat dikonversi ke format yang kompatibel dengan MediaPipe dengan AI Edge Torch Generative API. Anda dapat menggunakan API untuk mengonversi model PyTorch menjadi model LiteRT (TensorFlow Lite) multi-tanda tangan. Untuk mengetahui detail selengkapnya tentang pemetaan dan ekspor model, buka halaman GitHub AI Edge Torch.

Mengonversi model PyTorch dengan AI Edge Torch Generative API meliputi langkah-langkah berikut:

  1. Download checkpoint model PyTorch.
  2. Gunakan AI Edge Torch Generative API untuk membuat, mengonversi, dan mengkuantikasi model ke format file yang kompatibel dengan MediaPipe (.tflite).
  3. Buat Task Bundle (.task) dari file tflite dan tokenizer model.

Konverter Torch Generative hanya mengonversi untuk CPU dan memerlukan mesin Linux dengan RAM minimal 64 GB.

Untuk membuat Task Bundle, gunakan skrip paket untuk membuat Task Bundle. Proses pengelompokan mengemas model yang dipetakan dengan metadata tambahan (misalnya, Parameter Pengurai) yang diperlukan untuk menjalankan inferensi end-to-end.

Proses pengelompokan model memerlukan paket MediaPipe PyPI. Skrip konversi tersedia di semua paket MediaPipe setelah 0.10.14.

Instal dan impor dependensi dengan langkah-langkah berikut:

$ python3 -m pip install mediapipe

Gunakan library genai.bundler untuk memaketkan model:

import mediapipe as mp
from mediapipe.tasks.python.genai import bundler

config = bundler.BundleConfig(
    tflite_model=TFLITE_MODEL,
    tokenizer_model=TOKENIZER_MODEL,
    start_token=START_TOKEN,
    stop_tokens=STOP_TOKENS,
    output_filename=OUTPUT_FILENAME,
    enable_bytes_to_unicode_mapping=ENABLE_BYTES_TO_UNICODE_MAPPING,
)
bundler.create_bundle(config)
Parameter Deskripsi Nilai yang Diterima
tflite_model Jalur ke model TFLite yang diekspor AI Edge. JALUR
tokenizer_model Jalur ke model tokenizer SentencePiece. JALUR
start_token Token awal khusus model. Token awal harus ada dalam model tokenizer yang disediakan. STRING
stop_tokens Token perhentian khusus model. Token henti harus ada dalam model tokenizer yang disediakan. LIST[STRING]
output_filename Nama file paket tugas output. JALUR

Penyesuaian LoRA

API inferensi LLM Mediapipe dapat dikonfigurasi untuk mendukung Adaptasi Rangking Rendah (LoRA) untuk model bahasa besar. Dengan menggunakan model LoRA yang disesuaikan, developer dapat menyesuaikan perilaku LLM melalui proses pelatihan yang hemat biaya.

Dukungan LoRA dari LLM Inference API berfungsi untuk semua varian Gemma dan model Phi-2 untuk backend GPU, dengan bobot LoRA yang hanya berlaku untuk lapisan perhatian. Implementasi awal ini berfungsi sebagai API eksperimental untuk pengembangan mendatang dengan rencana untuk mendukung lebih banyak model dan berbagai jenis lapisan dalam update mendatang.

Menyiapkan model LoRA

Ikuti petunjuk di HuggingFace untuk melatih model LoRA yang telah disesuaikan pada set data Anda sendiri dengan jenis model yang didukung, Gemma atau Phi-2. Model Gemma-2 2B, Gemma 2B, dan Phi-2 tersedia di HuggingFace dalam format safetensors. Karena LLM Inference API hanya mendukung LoRA pada lapisan perhatian, hanya tentukan lapisan perhatian saat membuat LoraConfig sebagai berikut:

# For Gemma
from peft import LoraConfig
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
)

# For Phi-2
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "dense"],
)

Untuk pengujian, ada model LoRA yang disesuaikan dan dapat diakses secara publik yang sesuai dengan LLM Inference API yang tersedia di HuggingFace. Misalnya, monsterapi/gemma-2b-lora-maths-orca-200k untuk Gemma-2B dan lole25/phi-2-sft-ultrachat-lora untuk Phi-2.

Setelah melatih set data yang disiapkan dan menyimpan model, Anda akan mendapatkan file adapter_model.safetensors yang berisi bobot model LoRA yang telah disesuaikan. File safetensors adalah checkpoint LoRA yang digunakan dalam konversi model.

Sebagai langkah berikutnya, Anda perlu mengonversi bobot model menjadi Flatbuffer TensorFlow Lite menggunakan Paket Python MediaPipe. ConversionConfig harus menentukan opsi model dasar serta opsi LoRA tambahan. Perhatikan bahwa karena API hanya mendukung inferensi LoRA dengan GPU, backend harus disetel ke 'gpu'.

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

Konverter akan menghasilkan dua file flatbuffer TFLite, satu untuk model dasar dan satu lagi untuk model LoRA.

Inferensi model LoRA

Web, Android, dan iOS LLM Inference API diupdate untuk mendukung inferensi model LoRA.

Android mendukung LoRA statis selama inisialisasi. Untuk memuat model LoRA, pengguna menentukan jalur model LoRA serta LLM dasar.

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath('<path to base model>')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath('<path to LoRA model>')
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)

Untuk menjalankan inferensi LLM dengan LoRA, gunakan metode generateResponse() atau generateResponseAsync() yang sama dengan model dasar.